SGI Developer Toolbox 6.1/SGI Developer Toolbox 6.1 - Disc 4.iso/public/GNU/emacs.inst/emacs19.idb/usr/gnu/info/elisp-29.z/elisp-29

GNU Info File | 1994-08-02 | 50.5 KB | 1,236 lines

This is Info file elisp, produced by Makeinfo-1.55 from the input file
elisp.texi.

   This version is newer than the second printed edition of the GNU
Emacs Lisp Reference Manual.  It corresponds to Emacs Version 19.19.

   Published by the Free Software Foundation 675 Massachusetts Avenue
Cambridge, MA 02139 USA

   Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "GNU Emacs General Public License" is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "GNU Emacs General Public
License" may be included in a translation approved by the Free Software
Foundation instead of in the original English.


File: elisp,  Node: Holiday Customizing,  Next: Date Display Format,  Prev: Calendar Customizing,  Up: Calendar

Customizing the Holidays
========================

   Emacs knows about holidays defined by entries on one of several
lists.  You can customize theses lists of holidays to your own needs,
adding holidays or deleting lists of holidays.  The lists of holidays
that Emacs uses are for general holidays (`general-holidays'), local
holidays (`local-holidays'), Christian holidays (`christian-holidays'),
Hebrew (Jewish) holidays (`hebrew-holidays'), Islamic (Moslem) holidays
(`islamic-holidays'), and other holidays (`other-holidays').

   The general holidays are, by default, holidays common throughout the
United States.  To eliminate these holidays, set `general-holidays' to
`nil'.

   There are no default local holidays (but sites may supply some).  You
can set the variable `local-holidays' to any list of holidays, as
described below.

   By default, Emacs does not consider all the holidays of these
religions, only those commonly found in secular calendars.  For a more
extensive collection of religious holidays, you can set any (or all) of
the variables `all-christian-calendar-holidays',
`all-hebrew-calendar-holidays', or `all-islamic-calendar-holidays' to
`t'.  If you want to eliminate the religious holidays, set any or all
of the corresponding variables `christian-holidays', `hebrew-holidays',
and `islamic-holidays' to `nil'.

   You can set the variable `other-holidays' to any list of holidays.
This list, normally empty, is intended for your use.

   Each of the lists (`general-holidays', `local-holidays',
`christian-holidays', `hebrew-holidays', `islamic-holidays', and
`other-holidays') is a list of "holiday forms", each holiday form
describing a holiday (or sometimes a list of holidays).  Holiday forms
may have the following formats:

`(fixed MONTH DAY STRING)'
     A fixed date on the Gregorian calendar.  MONTH and DAY are
     numbers, STRING is the name of the holiday.

`(float MONTH DAYNAME K STRING)'
     The Kth DAYNAME in MONTH on the Gregorian calendar (DAYNAME=0 for
     Sunday, and so on); negative K means count back from the end of
     the month.  STRING is the name of the holiday.

`(hebrew MONTH DAY STRING)'
     A fixed date on the Hebrew calendar.  MONTH and DAY are numbers,
     STRING is the name of the holiday.

`(islamic MONTH DAY STRING)'
     A fixed date on the Islamic calendar.  MONTH and DAY are numbers,
     STRING is the name of the holiday.

`(julian MONTH DAY STRING)'
     A fixed date on the Julian calendar.  MONTH and DAY are numbers,
     STRING is the name of the holiday.

`(sexp SEXP STRING)'
     SEXP is a Lisp expression that should use the variable `year' to
     compute the date of a holiday, or `nil' if the holiday doesn't
     happen this year.  The value represents the date as a list of the
     form `(MONTH DAY YEAR)'.  STRING is the name of the holiday.

`(if BOOLEAN HOLIDAY-FORM &optional HOLIDAY-FORM)'
     A choice between two holidays based on the value of BOOLEAN.

`(FUNCTION &optional ARGS)'
     Dates requiring special computation; ARGS, if any, are passed in a
     list to the function `calendar-holiday-function-FUNCTION'.

   For example, suppose you want to add Bastille Day, celebrated in
France on July 14.  You can do this by adding the following line to
your `.emacs' file:

     (setq other-holidays '((fixed 7 14 "Bastille Day")))

The holiday form `(fixed 7 14 "Bastille Day")' specifies the fourteenth
day of the seventh month (July).

   Many holidays occur on a specific day of the week, at a specific time
of month.  Here is a holiday form describing Hurricane Supplication Day,
celebrated in the Virgin Islands on the fourth Monday in August:

     (float 8 1 4 "Hurricane Supplication Day")

Here the 8 specifies August, the 1 specifies Monday (Sunday is 0,
Tuesday is 2, and so on), and the 4 specifies the fourth occurrence in
the month (1 specifies the first occurrence, 2 the second occurrence,
-1 the last occurrence, -2 the second-to-last occurrence, and so on).

   You can specify holidays that occur on fixed days of the Hebrew,
Islamic, and Julian calendars too.  For example,

     (setq other-holidays
           '((hebrew 10 2 "Last day of Hanukkah")
             (islamic 3 12 "Mohammed's Birthday")
             (julian 4 2 "Jefferson's Birthday")))

adds the last day of Hanukkah (since the Hebrew months are numbered with
1 starting from Nisan), the Islamic feast celebrating Mohammed's
birthday (since the Islamic months are numbered from 1 starting with
Muharram), and Thomas Jefferson's birthday, which is 2 April 1743 on the
Julian calendar.

   To include a holiday conditionally, use either the `if' or the
`sexp' form.  For example, American presidential elections occur on the
first Tuesday after the first Monday in November of years divisible by
4:

     (sexp (if (= 0 (% year 4))
               (calendar-gregorian-from-absolute
                 (1+ (calendar-dayname-on-or-before
                        1 (+ 6 (calendar-absolute-from-gregorian
                                 (list 11 1 year))))))
           "US Presidential Election"))

or

     (if (= 0 (% displayed-year 4))
         (fixed 11
                (extract-calendar-day
                  (calendar-gregorian-from-absolute
                    (1+ (calendar-dayname-on-or-before
                          1 (+ 6 (calendar-absolute-from-gregorian
                                   (list 11 1 displayed-year)))))))
                "US Presidential Election"))

   Some holidays just don't fit into any of these forms because special
calculations are involved in their determination.  In such cases you
must write a Lisp function to do the calculation.  To include eclipses
of the sun, for example, add `(eclipses)' to `other-holidays' and write
an Emacs Lisp function `calendar-holiday-function-eclipses' that
returns a (possibly empty) list of the relevant Gregorian dates among
the range visible in the calendar window, with descriptive strings, like
this:

     (((6 27 1991) "Lunar Eclipse") ((7 11 1991) "Solar Eclipse") ... )


File: elisp,  Node: Date Display Format,  Next: Time Display Format,  Prev: Holiday Customizing,  Up: Calendar

Date Display Format
===================

   You can customize the manner of displaying dates in the diary, in
mode lines, and in messages by setting `calendar-date-display-form'.
This variable is a list of expressions that can involve the variables
`month', `day', and `year', all numbers in string form, and `monthname'
and `dayname', both alphabetic strings.  In the American style, the
default value of this list is as follows:

     ((if dayname (concat dayname ", ")) monthname " " day ", " year)

while in the European style this value is the default:

     ((if dayname (concat dayname ", ")) day " " monthname " " year)

   The ISO standard date representation is this:

     (year "-" month "-" day)

This specifies a typical American format:

     (month "/" day "/" (substring year -2))


File: elisp,  Node: Time Display Format,  Next: Daylight Savings,  Prev: Date Display Format,  Up: Calendar

Time Display Format
===================

   In the calendar, diary, and related buffers, Emacs displays times of
day in the conventional American style with the hours from 1 through 12,
minutes, and either `am' or `pm'.  If you prefer the "military"
(European) style of writing times--in which the hours go from 00 to
23--you can alter the variable `calendar-time-display-form'.  This
variable is a list of expressions that can involve the variables
`12-hours', `24-hours', and `minutes', all numbers in string form, and
`am-pm' and `time-zone', both alphabetic strings.  The default
definition of `calendar-time-display-form' is as follows:

     (12-hours ":" minutes am-pm
               (if time-zone " (") time-zone (if time-zone ")"))

   Setting `calendar-time-display-form' to

     (24-hours ":" minutes
               (if time-zone " (") time-zone (if time-zone ")"))

gives military-style times like `21:07 (UT)' if time zone names are
defined, and times like `21:07' if they are not.


File: elisp,  Node: Daylight Savings,  Next: Diary Customizing,  Prev: Time Display Format,  Up: Calendar

Daylight Savings Time
=====================

   Emacs understands the difference between standard time and daylight
savings time--the times given for sunrise, sunset, solstices,
equinoxes, and the phases of the moon take that into account.  The
default starting and stopping dates for daylight savings time are the
present-day American rules of the first Sunday in April until the last
Sunday in October, but you can specify whatever rules you want by
setting `calendar-daylight-savings-starts' and
`calendar-daylight-savings-ends'.  Their values should be Lisp
expressions that refer to the variable `year', and evaluate to the
Gregorian date on which daylight savings time starts or (respectively)
ends, in the form of a list `(MONTH DAY YEAR)'.

   Emacs uses these expressions to determine the starting date of
daylight savings time for the holiday list and for correcting times of
day in the solar and lunar calculations.

   The default value of `calendar-daylight-savings-starts' is this,

     (calendar-nth-named-day 1 0 4 year)

which computes the first 0th day (Sunday) of the fourth month (April) in
the year specified by `year'.  If daylight savings time were changed to
start on October 1, you would set `calendar-daylight-savings-starts' to

     (list 10 1 year)

   For a more complex example, suppose daylight savings time begins on
the first of Nisan on the Hebrew calendar.  You would set
`calendar-daylight-savings-starts' to

     (calendar-gregorian-from-absolute
       (calendar-absolute-from-hebrew
         (list 1 1 (+ year 3760))))

because Nisan is the first month in the Hebrew calendar and the Hebrew
year differs from the Gregorian year by 3760 at Nisan.

   If there is no daylight savings time at your location, or if you want
all times in standard time, set `calendar-daylight-savings-starts' and
`calendar-daylight-savings-ends' to `nil'.


File: elisp,  Node: Diary Customizing,  Next: Hebrew/Islamic Entries,  Prev: Daylight Savings,  Up: Calendar

Customizing the Diary
=====================

   Ordinarily, the mode line of the diary buffer window indicates any
holidays that fall on the date of the diary entries.  The process of
checking for holidays can take several seconds, so including holiday
information delays the display of the diary buffer noticeably.  If you'd
prefer to have a faster display of the diary buffer but without the
holiday information, set the variable `holidays-in-diary-buffer' to
`nil'.

   The variable `number-of-diary-entries' controls the number of days
of diary entries to be displayed at one time.  It affects the initial
display when `view-diary-entries-initially' is `t', as well as the
command `M-x diary'.  For example, the default value is 1, which says
to display only the current day's diary entries.  If the value is 2,
both the current day's and the next day's entries are displayed.  The
value can also be a vector of seven elements: if the value is `[0 2 2 2
2 4 1]' then no diary entries appear on Sunday, the current date's and
the next day's diary entries appear Monday through Thursday, Friday
through Monday's entries appear on Friday, while on Saturday only that
day's entries appear.

   The variable `print-diary-entries-hook' is a normal hook run after
preparation of a temporary buffer containing just the diary entries
currently visible in the diary buffer.  (The other, irrelevant diary
entries are really absent from the temporary buffer; in the diary
buffer, they are merely hidden.)  The default value of this hook does
the printing with the command `lpr-buffer'.  If you want to use a
different command to do the printing, just change the value of this
hook.  Other uses might include, for example, rearranging the lines into
order by day and time.

   You can customize the form of dates in your diary file, if neither
the standard American nor European styles suits your needs, by setting
the variable `diary-date-forms'.  This variable is a list of forms of
dates recognized in the diary file.  Each form is a list of regular
expressions (*note Regular Expressions::.) and the variables `month',
`day', `year', `monthname', and `dayname'.  The variable `monthname'
matches the name of the month, capitalized or not, or its three-letter
abbreviation, followed by a period or not; it matches `*'.  Similarly,
`dayname' matches the name of the day, capitalized or not, or its
three-letter abbreviation, followed by a period or not.  The variables
`month', `day', and `year' match those numerical values, preceded by
arbitrarily many zeros; they also match `*'.  The default value of
`diary-date-forms' in the American style is

     ((month "/" day "[^/0-9]")
      (month "/" day "/" year "[^0-9]")
      (monthname " *" day "[^,0-9]")
      (monthname " *" day ", *" year "[^0-9]")
      (dayname "\\W"))

Emacs matches of the diary entries with the date forms is done with the
standard syntax table from Fundamental mode (*note Syntax Tables::.),
but with the `*' changed so that it is a word constituent.

   The forms on the list must be *mutually exclusive* and must not
match any portion of the diary entry itself, just the date.  If, to be
mutually exclusive, the pattern must match a portion of the diary entry
itself, the first element of the form *must* be `backup'.  This causes
the date recognizer to back up to the beginning of the current word of
the diary entry.  Even if you use `backup', the form must absolutely
not match more than a portion of the first word of the diary entry.
The default value of `diary-date-forms' in the European style is this
list:

     ((day "/" month "[^/0-9]")
      (day "/" month "/" year "[^0-9]")
      (backup day " *" monthname "\\W+\\<[^*0-9]")
      (day " *" monthname " *" year "[^0-9]")
      (dayname "\\W"))

Notice the use of `backup' in the middle form because part of the diary
entry must be matched to distinguish this form from the following one.


File: elisp,  Node: Hebrew/Islamic Entries,  Next: Fancy Diary Display,  Prev: Diary Customizing,  Up: Calendar

Hebrew- and Islamic-Date Diary Entries
======================================

   Your diary file can have entries based on Hebrew or Islamic dates, as
well as entries based on our usual Gregorian calendar.  However, because
the processing of such entries is time-consuming and most people don't
need them, you must customize the processing of your diary file to
specify that you want such entries recognized.  If you want Hebrew-date
diary entries, for example, you must include these lines in your
`.emacs' file:

     (setq nongregorian-diary-listing-hook 'list-hebrew-diary-entries)
     (setq nongregorian-diary-marking-hook 'mark-hebrew-diary-entries)

If you want Islamic-date entries, include these lines in your `.emacs'
file:

     (setq nongregorian-diary-listing-hook 'list-islamic-diary-entries)
     (setq nongregorian-diary-marking-hook 'mark-islamic-diary-entries)

If you want both Hebrew- and Islamic-date entries, include these lines:

     (setq nongregorian-diary-listing-hook
           '(list-hebrew-diary-entries list-islamic-diary-entries))
     (setq nongregorian-diary-marking-hook
           '(mark-hebrew-diary-entries mark-islamic-diary-entries))

   Hebrew- and Islamic-date diary entries have the same formats as
Gregorian-date diary entries, except that the date must be preceded with
an `H' for Hebrew dates and an `I' for Islamic dates.  Moreover,
because the Hebrew and Islamic month names are not uniquely specified
by the first three letters, you may not abbreviate them.  For example,
a diary entry for the Hebrew date Heshvan 25 could look like

     HHeshvan 25 Happy Hebrew birthday!

and would appear in the diary for any date that corresponds to Heshvan
25 on the Hebrew calendar.  Similarly, an Islamic-date diary entry
might be

     IDhu al-Qada 25 Happy Islamic birthday!

and would appear in the diary for any date that corresponds to Dhu
al-Qada 25 on the Islamic calendar.

   As with Gregorian-date diary entries, Hebrew- and Islamic-date
entries are nonmarking if they are preceded with an ampersand (`&').

   There are commands to help you in making Hebrew- and Islamic-date
entries to your diary:

`i h d'
     Add a diary entry for the Hebrew date corresponding to the
     selected date (`insert-hebrew-diary-entry').

`i h m'
     Add a diary entry for the day of the Hebrew month corresponding to
     the selected date (`insert-monthly-hebrew-diary-entry').

`i h y'
     Add a diary entry for the day of the Hebrew year corresponding to
     the selected date (`insert-yearly-hebrew-diary-entry').

`i i d'
     Add a diary entry for the Islamic date corresponding to the
     selected date (`insert-islamic-diary-entry').

`i i m'
     Add a diary entry for the day of the Islamic month corresponding
     to the selected date (`insert-monthly-islamic-diary-entry').

`i i y'
     Add a diary entry for the day of the Islamic year corresponding to
     the selected date (`insert-yearly-islamic-diary-entry').

   These commands work exactly like the corresponding commands for
ordinary diary entries: Move point to a date in the calendar window and
the above commands insert the Hebrew or Islamic date (corresponding to
the date indicated by point) at the end of your diary file and you can
then type the diary entry.  If you want the diary entry to be
nonmarking, give a numeric argument to the command.


File: elisp,  Node: Fancy Diary Display,  Next: Included Diary Files,  Prev: Hebrew/Islamic Entries,  Up: Calendar

Fancy Diary Display
===================

   Diary display works by preparing the diary buffer and then running
the hook `diary-display-hook'.  The default value of this hook hides
the irrelevant diary entries and then displays the buffer
(`simple-diary-display').  However, if you specify the hook as follows,

     (add-hook 'diary-display-hook 'fancy-diary-display)

then fancy mode displays diary entries and holidays by copying them into
a special buffer that exists only for display.  Copying provides an
opportunity to change the displayed text to make it prettier--for
example, to sort the entries by the dates they apply to.

   As with simple diary display, you can print a hard copy of the buffer
with `print-diary-entries'.  To print a hard copy of a day-by-day diary
for a week by positioning point on Sunday of that week, type `7 d' and
then do `M-x print-diary-entries'.  As usual, the inclusion of the
holidays slows down the display slightly; you can speed things up by
setting the variable `holidays-in-diary-buffer' to `nil'.

   Ordinarily, the fancy diary buffer does not show days for which
there are no diary entries, even if that day is a holiday.  If you want
such days to be shown in the fancy diary buffer, set the variable
`diary-list-include-blanks' to `t'.

   If you use the fancy diary display, you can use the normal hook
`list-diary-entries-hook' to sort each day's diary entries by their
time of day.  Add this line to your `.emacs' file:

     (add-hook 'list-diary-entries-hook 'sort-diary-entries)

For each day, this sorts diary entries that begin with a recognizable
time of day according to their times.  Diary entries without times come
first within each day.


File: elisp,  Node: Included Diary Files,  Next: Sexp Diary Entries,  Prev: Fancy Diary Display,  Up: Calendar

Included Diary Files
====================

   If you use the fancy diary display, you can have diary entries from
other files included with your own by an "include" mechanism.  This
facility makes possible the sharing of common diary files among groups
of users.  Lines in the diary file of this form:

     #include "FILENAME"

includes the diary entries from the file FILENAME in the fancy diary
buffer (because the ordinary diary buffer is just the buffer associated
with your diary file, you cannot use the include mechanism unless you
use the fancy diary buffer).  The include mechanism is recursive, by
the way, so that included files can include other files, and so on; you
must be careful not to have a cycle of inclusions, of course.  To
enable the include facility, add lines as follows to your `.emacs' file:

     (add-hook 'list-diary-entries-hook 'include-other-diary-files)
     (add-hook 'mark-diary-entries-hook 'mark-included-diary-files)


File: elisp,  Node: Sexp Diary Entries,  Next: Appt Customizing,  Prev: Included Diary Files,  Up: Calendar

Sexp Entries and the Fancy Diary Display
========================================

   Sexp diary entries allow you to do more than just have complicated
conditions under which a diary entry applies.  If you use the fancy
diary display, sexp entries can generate the text of the entry depending
on the date itself.  For example, an anniversary diary entry can insert
the number of years since the anniversary date into the text of the
diary entry.  Thus the `%d' in this dairy entry:

     %%(diary-anniversary 10 31 1948) Arthur's birthday (%d years old)

gets replaced by the age, so on October 31, 1990 the entry appears in
the fancy diary buffer like this:

     Arthur's birthday (42 years old)

If the diary file instead contains this entry:

     %%(diary-anniversary 10 31 1948) Arthur's %d%s birthday

the entry in the fancy diary buffer for October 31, 1990 appears like
this:

     Arthur's 42nd birthday

   Similarly, cyclic diary entries can interpolate the number of
repetitions that have occurred:

     %%(diary-cyclic 50 1 1 1990) Renew medication (%d%s time)

looks like this:

     Renew medication (5th time)

in the fancy diary display on September 8, 1990.

   The generality of sexp diary entries lets you specify any diary entry
that you can describe algorithmically.  Suppose you get paid on the 21st
of the month if it is a weekday, and to the Friday before if the 21st is
on a weekend.  The diary entry

     &%%(let ((dayname (calendar-day-of-week date))
              (day (car (cdr date))))
           (or (and (= day 21) (memq dayname '(1 2 3 4 5)))
               (and (memq day '(19 20)) (= dayname 5)))
              ) Pay check deposited

applies to just those dates.  This example illustrates how the sexp can
depend on the variable `date'; this variable is a list (MONTH DAY YEAR)
that gives the Gregorian date for which the diary entries are being
found.  If the value of the expression is `t', the entry applies to
that date.  If the expression evaluates to `nil', the entry does *not*
apply to that date.

   The following sexp diary entries take advantage of the ability (in
the fancy diary display) to concoct diary entries based on the date:

`%%(diary-sunrise-sunset)'
     Make a diary entry for the local times of today's sunrise and
     sunset.

`%%(diary-phases-of-moon)'
     Make a diary entry for the phases (quarters) of the moon.

`%%(diary-day-of-year)'
     Make a diary entry with today's day number in the current year and
     the number of days remaining in the current year.

`%%(diary-iso-date)'
     Make a diary entry with today's equivalent ISO commercial date.

`%%(diary-julian-date)'
     Make a diary entry with today's equivalent date on the Julian
     calendar.

`%%(diary-astro-day-number)'
     Make a diary entry with today's equivalent astronomical (Julian)
     day number.

`%%(diary-hebrew-date)'
     Make a diary entry with today's equivalent date on the Hebrew
     calendar.

`%%(diary-islamic-date)'
     Make a diary entry with today's equivalent date on the Islamic
     calendar.

`%%(diary-french-date)'
     Make a diary entry with today's equivalent date on the French
     Revolutionary calendar.

`%%(diary-mayan-date)'
     Make a diary entry with today's equivalent date on the Mayan
     calendar.

Thus including the diary entry

     &%%(diary-hebrew-date)

causes every day's diary display to contain the equivalent date on the
Hebrew calendar, if you are using the fancy diary display.  (With simple
diary display, the line `&%%(diary-hebrew-date)' appears in the diary
for any date, but does nothing particularly useful.)

   There are a number of other available sexp diary entries that are
important to those who follow the Hebrew calendar:

`%%(diary-rosh-hodesh)'
     Make a diary entry that tells the occurrence and ritual
     announcement of each new Hebrew month.

`%%(diary-parasha)'
     Make a Saturday diary entry that tells the weekly synagogue
     scripture reading.

`%%(diary-sabbath-candles)'
     Make a Friday diary entry that tells the *local time* of Sabbath
     candle lighting.

`%%(diary-omer)'
     Make a diary entry that gives the omer count, when appropriate.

`%%(diary-yahrzeit MONTH DAY YEAR) NAME'
     Make a diary entry marking the anniversary of a date of death.
     The date is the *Gregorian* (civil) date of death.  The diary
     entry appears on the proper Hebrew calendar anniversary and on the
     day before.  (In the European style, the order of the parameters
     is changed to DAY, MONTH, YEAR.)


File: elisp,  Node: Appt Customizing,  Prev: Sexp Diary Entries,  Up: Calendar

Customizing Appointment Reminders
=================================

   You can specify exactly how Emacs reminds you of an appointment and
how far in advance it begins doing so.  Here are the variables that you
can set:

`appt-message-warning-time'
     The time in minutes before an appointment that the reminder
     begins.  The default is 10 minutes.

`appt-audible'
     If this is `t' (the default), Emacs rings the terminal bell for
     appointment reminders.

`appt-visible'
     If this is `t' (the default), Emacs displays the appointment
     message in echo area.

`appt-display-mode-line'
     If this is `t' (the default), Emacs displays the number of minutes
     to the appointment on the mode line.

`appt-msg-window'
     If this is `t' (the default), Emacs displays the appointment
     message in another window.

`appt-display-duration'
     The number of seconds an appointment message is displayed.  The
     default is 5 seconds.


File: elisp,  Node: Tips,  Next: GNU Emacs Internals,  Prev: Calendar,  Up: Top

Tips and Standards
******************

   This chapter describes no additional features of Emacs Lisp.
Instead it gives advice on making effective use of the features
described in the previous chapters.

* Menu:

* Style Tips::                Writing clean and robust programs.
* Compilation Tips::          Making compiled code run fast.
* Documentation Tips::        Writing readable documentation strings.
* Comment Tips::          Conventions for writing comments.
* Library Headers::           Standard headers for library packages.


File: elisp,  Node: Style Tips,  Next: Compilation Tips,  Up: Tips

Writing Clean Lisp Programs
===========================

   Here are some tips for avoiding common errors in writing Lisp code
intended for widespread use:

   * Since all global variables share the same name space, and all
     functions share another name space, you should choose a short word
     to distinguish your program from other Lisp programs.  Then take
     care to begin the names of all global variables, constants, and
     functions with the chosen prefix.  This helps avoid name conflicts.

     This recommendation applies even to names for traditional Lisp
     primitives that are not primitives in Emacs Lisp--even to `cadr'.
     Believe it or not, there is more than one plausible way to define
     `cadr'.  Play it safe; append your name prefix to produce a name
     like `foo-cadr' or `mylib-cadr' instead.

     If one prefix is insufficient, your package may use two or three
     alternative common prefixes, so long as they make sense.

     Separate the prefix from the rest of the symbol name with a hyphen,
     `-'.  This will be consistent with Emacs itself and with most Emacs
     Lisp programs.

   * It is often useful to put a call to `provide' in each separate
     library program, at least if there is more than one entry point to
     the program.

   * If one file FOO uses a macro defined in another file BAR, FOO
     should contain `(require 'BAR)' before the first use of the macro.
     (And BAR should contain `(provide 'BAR)', to make the `require'
     work.)  This will cause BAR to be loaded when you byte-compile
     FOO.  Otherwise, you risk compiling FOO without the necessary
     macro loaded, and that would produce compiled code that won't work
     right.  *Note Compiling Macros::.

   * If you define a major mode, make sure to run a hook variable using
     `run-hooks', just as the existing major modes do.  *Note Hooks::.

   * Please do not define `C-c LETTER' as a key in your major modes.
     These sequences are reserved for users; they are the *only*
     sequences reserved for users, so we cannot do without them.

     Instead, define sequences consisting of `C-c' followed by a
     non-letter.  These sequences are reserved for major modes.

     Changing all the major modes in Emacs 18 so they would follow this
     convention was a lot of work.  Abandoning this convention would
     waste that work and inconvenience the users.

   * It is a bad idea to define aliases for the Emacs primitives.  Use
     the standard names instead.

   * Redefining an Emacs primitive is an even worse idea.  It may do
     the right thing for a particular program, but there is no telling
     what other programs might break as a result.

   * If a file does replace any of the functions or library programs of
     standard Emacs, prominent comments at the beginning of the file
     should say which functions are replaced, and how the behavior of
     the replacements differs from that of the originals.

   * If a file requires certain standard library programs to be loaded
     beforehand, then the comments at the beginning of the file should
     say so.

   * Please keep the names of your Emacs Lisp source files to 13
     characters or less.  This way, if the files are compiled, the
     compiled files' names will be 14 characters or less, which is
     short enough to fit on all kinds of Unix systems.

   * Don't use `next-line' or `previous-line' in programs; nearly
     always, `forward-line' is more convenient as well as more
     predictable and robust.  *Note Text Lines::.

   * Don't use functions that set the mark in your Lisp code (unless
     you are writing a command to set the mark).  The mark is a
     user-level feature, so it is incorrect to change the mark except
     to supply a value for the user's benefit.  *Note The Mark::.

     In particular, don't use these functions:

        * `beginning-of-buffer', `end-of-buffer'

        * `replace-string', `replace-regexp'

     If you just want to move point, or replace a certain string,
     without any of the other features intended for interactive users,
     you can replace these functions with one or two lines of simple
     Lisp code.

   * The recommended way to print a message in the echo area is with
     the `message' function, not `princ'.  *Note The Echo Area::.

   * When you encounter an error condition, call the function `error'
     (or `signal').  The function `error' does not return.  *Note
     Signaling Errors::.

     Do not use `message', `throw', `sleep-for', or `beep' to report
     errors.

   * Avoid using recursive edits.  Instead, do what the Rmail `w'
     command does: use a new local keymap that contains one command
     defined to switch back to the old local keymap.  Or do what the
     `edit-options' command does: switch to another buffer and let the
     user switch back at will.  *Note Recursive Editing::.

   * In some other systems there is a convention of choosing variable
     names that begin and end with `*'.  We don't use that convention
     in Emacs Lisp, so please don't use it in your library.  (In fact,
     in Emacs names of this form are conventionally used for
     program-generated buffers.) The users will find Emacs more
     coherent if all libraries use the same conventions.

   * Indent each function with `C-M-q' (`indent-sexp') using the
     default indentation parameters.

   * Don't make a habit of putting close-parentheses on lines by
     themselves; Lisp programmers find this disconcerting.  Once in a
     while, when there is a sequence of many consecutive
     close-parentheses, it may make sense to split them in one or two
     significant places.

   * Please put a copyright notice on the file if you give copies to
     anyone.  Use the same lines that appear at the top of the Lisp
     files in Emacs itself.  If you have not signed papers to assign
     the copyright to the Foundation, then place your name in the
     copyright notice in place of the Foundation's name.


File: elisp,  Node: Compilation Tips,  Next: Documentation Tips,  Prev: Style Tips,  Up: Tips

Tips for Making Compiled Code Fast
==================================

   Here are ways of improving the execution speed of byte-compiled lisp
programs.

   * Use the `profile' library to profile your program.  See the file
     `profile.el' for instructions.

   * Use iteration rather than recursion whenever possible.  Function
     calls are slow in Emacs Lisp even when a compiled function is
     calling another compiled function.

   * Using the primitive list-searching functions `memq', `assq' or
     `assoc' is even faster than explicit iteration.  It may be worth
     rearranging a data structure so that one of these primitive search
     functions can be used.

   * Certain built-in functions are handled specially by the byte
     compiler avoiding the need for an ordinary function call.  It is a
     good idea to use these functions rather than alternatives.  To see
     whether a function is handled specially by the compiler, examine
     its `byte-compile' property.  If the property is non-`nil', then
     the function is handled specially.

     For example, the following input will show you that `aref' is
     compiled specially (*note Array Functions::.) while `elt' is not
     (*note Sequence Functions::.):

          (get 'aref 'byte-compile)
               => byte-compile-two-args

          (get 'elt 'byte-compile)
               => nil

   * Make small functions inline, so that calls to them in compiled
     code run faster.  *Note Inline Functions::.


File: elisp,  Node: Documentation Tips,  Next: Comment Tips,  Prev: Compilation Tips,  Up: Tips

Tips for Documentation Strings
==============================

   Here are some tips for the writing of documentation strings.

   * Every command, function or variable intended for users to know
     about should have a documentation string.

   * An internal subroutine of a Lisp program need not have a
     documentation string, and you can save space by using a comment
     instead.

   * The first line of the documentation string should consist of one
     or two complete sentences which stand on their own as a summary.
     In particular, start the line with a capital letter and end with a
     period.

     The documentation string can have additional lines which expand on
     the details of how to use the function or variable.  The
     additional lines should be made up of complete sentences also, but
     they may be filled if that looks good.

   * Do not start or end a documentation string with whitespace.

   * Format the documentation string so that it fits in an Emacs window
     on an 80 column screen.  It is a good idea for most lines to be no
     wider than 60 characters.  The first line can be wider if
     necessary to fit the information that ought to be there.

     However, rather than simply filling the entire documentation
     string, you can make it much more readable by choosing line breaks
     with care.  Use blank lines between topics if the documentation
     string is long.

   * *Do not* indent subsequent lines of a documentation string so that
     the text is lined up in the source code with the text of the first
     line.  This looks nice in the source code, but looks bizarre when
     users view the documentation.  Remember that the indentation
     before the starting double-quote is not part of the string!

   * A variable's documentation string should start with `*' if the
     variable is one that users would want to set interactively often.
     If the value is a long list, or a function, or if the variable
     would only be set in init files, then don't start the
     documentation string with `*'.  *Note Defining Variables::.

   * The documentation string for a variable that is a yes-or-no flag
     should start with words such as "Non-nil means...", to make it
     clear both that the variable only has two meaningfully distinct
     values and which value means "yes".

   * When a function's documentation string mentions the value of an
     argument of the function, use the argument name in capital letters
     as if it were a name for that value.  Thus, the documentation
     string of the function `/' refers to its second argument as
     `DIVISOR'.

     Also use all caps for meta-syntactic variables, such as when you
     show the decomposition of a list or vector into subunits, some of
     which may be variable.

   * When a documentation string refers to a Lisp symbol, write it as it
     would be printed (which usually means in lower case), with
     single-quotes around it.  For example: ``lambda''.  There are two
     exceptions: write `t' and `nil' without single-quotes.

   * Don't write key sequences directly in documentation strings.
     Instead, use the `\\[...]' construct to stand for them.  For
     example, instead of writing `C-f', write `\\[forward-char]'.  When
     the documentation string is printed, Emacs will substitute
     whatever key is currently bound to `forward-char'.  This will
     usually be `C-f', but if the user has moved key bindings, it will
     be the correct key for that user.  *Note Keys in Documentation::.

   * In documentation strings for a major mode, you will want to refer
     to the key bindings of that mode's local map, rather than global
     ones.  Therefore, use the construct `\\<...>' once in the
     documentation string to specify which key map to use.  Do this
     before the first use of `\\[...]'.  The text inside the `\\<...>'
     should be the name of the variable containing the local keymap for
     the major mode.

     It is not practical to use `\\[...]' very many times, because
     display of the documentation string will become slow.  So use this
     to describe the most important commands in your major mode, and
     then use `\\{...}' to display the rest of the mode's keymap.

   * Don't use the term "Elisp", since that is or was a trademark.  Use
     the term "Emacs Lisp".


File: elisp,  Node: Comment Tips,  Next: Library Headers,  Prev: Documentation Tips,  Up: Tips

Tips on Writing Comments
========================

   We recommend these conventions for where to put comments and how to
indent them:

`;'
     Comments that start with a single semicolon, `;', should all be
     aligned to the same column on the right of the source code.  Such
     comments usually explain how the code on the same line does its
     job.  In Lisp mode and related modes, the `M-;'
     (`indent-for-comment') command automatically inserts such a `;' in
     the right place, or aligns such a comment if it is already
     inserted.

     (The following examples are taken from the Emacs sources.)

          (setq base-version-list                 ; there was a base
                (assoc (substring fn 0 start-vn)  ; version to which
                       file-version-assoc-list))  ; this looks like
                                                  ; a subversion

`;;'
     Comments that start with two semicolons, `;;', should be aligned to
     the same level of indentation as the code.  Such comments are used
     to describe the purpose of the following lines or the state of the
     program at that point.  For example:

          (prog1 (setq auto-fill-function
                       ...
                       ...
            ;; update mode-line
            (force-mode-line-update)))

     These comments are also written before a function definition to
     explain what the function does and how to call it properly.

`;;;'
     Comments that start with three semicolons, `;;;', should start at
     the left margin.  Such comments are not used within function
     definitions, but are used to make more general comments.  For
     example:

          ;;; This Lisp code is run in Emacs
          ;;; when it is to operate as a server
          ;;; for other processes.

`;;;;'
     Comments that start with four semicolons, `;;;;', should be aligned
     to the left margin and are used for headings of major sections of a
     program.  For example:

          ;;;; The kill ring

The indentation commands of the Lisp modes in Emacs, such as `M-;'
(`indent-for-comment') and TAB (`lisp-indent-line') automatically
indent comments according to these conventions, depending on the the
number of semicolons.  *Note Manipulating Comments: (emacs)Comments.

   If you wish to "comment out" a number of lines of code, use triple
semicolons at the beginnings of the lines.

   Any character may be included in a comment, but it is advisable to
precede a character with syntactic significance in Lisp (such as `\' or
unpaired `(' or `)') with a `\', to prevent it from confusing the Emacs
commands for editing Lisp.


File: elisp,  Node: Library Headers,  Prev: Comment Tips,  Up: Tips

Conventional Headers for Emacs Libraries
========================================

   Emacs 19 has conventions for using special comments in Lisp libraries
to divide them into sections and give information such as who wrote
them.  This section explains these conventions.  First, an example:

     ;;; lisp-mnt.el --- minor mode for Emacs Lisp maintainers

     ;; Copyright (C) 1992 Free Software Foundation, Inc.

     ;; Author: Eric S. Raymond <[e-mail]>
     ;; Maintainer: Eric S. Raymond <[e-mail]>
     ;; Created: 14 Jul 1992
     ;; Version: 1.2
     ;; Keywords: docs

     ;; This file is part of GNU Emacs.
     COPYING CONDITIONS...

   The very first line should have this format:

     ;;; FILENAME --- DESCRIPTION

The description should be complete in one line.

   After the copyright notice come several "header comment" lines, each
beginning with `;;; HEADER-NAME:'.  Here is a table of the conventional
possibilities for HEADER-NAME:

`Author'
     This line states the name and net address of at least the principal
     author of the library.

     If there are multiple authors, you can list them on continuation
     lines led by `;;<TAB>', like this:

          ;; Author: Ashwin Ram <[e-mail]>
          ;;    Dave Sill <[e-mail]>
          ;;    Dave Brennan <[e-mail]>
          ;;    Eric Raymond <[e-mail]>

`Maintainer'
     This line should contain a single name/address as in the Author
     line, or an address only, or the string "FSF".  If there is no
     maintainer line, the person(s) in the Author field are presumed to
     be the maintainers.  The example above is mildly bogus because the
     maintainer line is redundant.

     The idea behind the `Author' and `Maintainer' lines is to make
     possible a Lisp function to "send mail to the maintainer" without
     having to mine the name out by hand.

     Be sure to surround the network address with `<...>' if you
     include the person's full name as well as the network address.

`Created'
     This optional line gives the original creation date of the file.
     For historical interest only.

`Version'
     If you wish to record version numbers for the individual Lisp
     program, put them in this line.

`Adapted-By'
     In this header line, place the name of the person who adapted the
     library for installation (to make it fit the style conventions, for
     example).

`Keywords'
     This line lists keywords for the `finder-by-keyword' help command.
     This field is important; it's how people will find your package
     when they're looking for things by topic area.

   Just about every Lisp library ought to have the `Author' and
`Keywords' header comment lines.  Use the others if they are
appropriate.  You can also put in header lines with other header
names--they have no standard meanings, so they can't do any harm.

   We use additional stylized comments to subdivide the contents of the
library file.  Here is a table of them:

`;;; Commentary:'
     This begins introductory comments that explain how the library
     works.  It should come right after the copying permissions.

`;;; Change log:'
     This begins change log information stored in the library file (if
     you store the change history there).  For most of the Lisp files
     distributed with Emacs, the change history is kept in the file
     `ChangeLog' and not in the source file at all; these files do not
     have a `;;; Change log:' line.

`;;; Code:'
     This begins the actual code of the program.

`;;; FILENAME ends here'
     This is the "footer line"; it appears at the very end of the file.
     Its purpose is to enable people to detect truncated versions of
     the file from the lack of a footer line.


File: elisp,  Node: GNU Emacs Internals,  Next: Standard Errors,  Prev: Tips,  Up: Top

GNU Emacs Internals
*******************

   This chapter describes how the runnable Emacs executable is dumped
with the preloaded Lisp libraries in it, how storage is allocated, and
some internal aspects of GNU Emacs that may be of interest to C
programmers.

* Menu:

* Building Emacs::      How to preload Lisp libraries into Emacs.
* Pure Storage::        A kludge to make preloaded Lisp functions sharable.
* Garbage Collection::  Reclaiming space for Lisp objects no longer used.
* Object Internals::    Data formats of buffers, windows, processes.
* Writing Emacs Primitives::   Writing C code for Emacs.


File: elisp,  Node: Building Emacs,  Next: Pure Storage,  Prev: GNU Emacs Internals,  Up: GNU Emacs Internals

Building Emacs
==============

   The first step in building Emacs is to compile the C sources.  This
produces a program called `temacs', also called a "bare impure Emacs".
It contains the Emacs Lisp interpreter and I/O routines, but not the
editing commands.

   Then, to create a working Emacs editor, issue the `temacs -l loadup'
command.  This directs `temacs' to evaluate the Lisp files specified in
the file `loadup.el'.  These files set up the normal Emacs editing
environment, resulting in an Emacs which is still impure but no longer
bare.

   It takes a long time to load the standard Lisp files.  Luckily, you
don't have to do this each time you run Emacs; `temacs' can dump out an
executable program called `emacs' which has these files preloaded.
`emacs' starts more quickly because it does not need to load the files.
This is the program that is normally installed.

   To create `emacs', use the command `temacs -batch -l loadup dump'.
The purpose of `-batch' here is to prevent `temacs' from trying to
initialize any of its data on the terminal; this ensures that the
tables of terminal information are empty in the dumped Emacs.

   When the `emacs' executable is started, it automatically loads the
user's `.emacs' file, or the default initialization file `default.el'
if the user has none.  (*Note Starting Up::.)  With the `.emacs' file,
you can produce a version of Emacs that suits you and is not the same
as the version other people use.  With `default.el', you can customize
Emacs for all the users at your site who don't choose to customize it
for themselves.  (For further reflection: why is this different from
the case of the barber who shaves every man who doesn't shave himself?)

   On some systems, dumping does not work.  Then, you must start Emacs
with the `temacs -l loadup' command each time you use it.  This takes a
long time, but since you need to start Emacs once a day at most--and
once a week or less frequently if you never log out--the extra time is
not too severe a problem.

   Before `emacs' is dumped, the documentation strings for primitive
and preloaded functions (and variables) need to be found in the file
where they are stored.  This is done by calling `Snarf-documentation'
(*note Accessing Documentation::.).  These strings were moved out of
`emacs' to make it smaller.  *Note Documentation Basics::.

 - Function: dump-emacs TO-FILE FROM-FILE
     This function dumps the current state of Emacs into an executable
     file TO-FILE.  It takes symbols from FROM-FILE (this is normally
     the executable file `temacs').

     If you use this function in an Emacs that was already dumped, you
     must set `command-line-processed' to `nil' first for good results.
     *Note Command Line Arguments::.

 - Command: emacs-version
     This function returns a string describing the version of Emacs
     that is running.  It is useful to include this string in bug
     reports.

          (emacs-version)
            => "GNU Emacs 18.36.1 of Fri Feb 27 1987 on slug
               (berkeley-unix)"

     Called interactively, the function prints the same information in
     the echo area.

 - Variable: emacs-build-time
     The value of this variable is the time at which Emacs was built at
     the local site.

          emacs-build-time
               => "Fri Feb 27 14:55:57 1987"

 - Variable: emacs-version
     The value of this variable is the version of Emacs being run.  It
     is a string, e.g. `"18.36.1"'.